package org.jivesoftware.smack.util.collections;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.AbstractCollection;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.Set;

public class AbstractHashedMap<K, V> extends AbstractMap<K, V>
  implements IterableMap<K, V>
{
  protected static final String NO_NEXT_ENTRY = "No next() entry in the iteration";
  protected static final String NO_PREVIOUS_ENTRY = "No previous() entry in the iteration";
  protected static final String REMOVE_INVALID = "remove() can only be called once after next()";
  protected static final String GETKEY_INVALID = "getKey() can only be called after next() and before remove()";
  protected static final String GETVALUE_INVALID = "getValue() can only be called after next() and before remove()";
  protected static final String SETVALUE_INVALID = "setValue() can only be called after next() and before remove()";
  protected static final int DEFAULT_CAPACITY = 16;
  protected static final int DEFAULT_THRESHOLD = 12;
  protected static final float DEFAULT_LOAD_FACTOR = 0.75F;
  protected static final int MAXIMUM_CAPACITY = 1073741824;
  protected static final Object NULL = new Object();
  protected transient float loadFactor;
  protected transient int size;
  protected transient HashEntry<K, V>[] data;
  protected transient int threshold;
  protected transient int modCount;
  protected transient EntrySet<K, V> entrySet;
  protected transient KeySet<K, V> keySet;
  protected transient Values<K, V> values;

  protected AbstractHashedMap()
  {
  }

  protected AbstractHashedMap(int paramInt1, float paramFloat, int paramInt2)
  {
    this.loadFactor = paramFloat;
    this.data = new HashEntry[paramInt1];
    this.threshold = paramInt2;
    init();
  }

  protected AbstractHashedMap(int paramInt)
  {
    this(paramInt, 0.75F);
  }

  protected AbstractHashedMap(int paramInt, float paramFloat)
  {
    if (paramInt < 1)
      throw new IllegalArgumentException("Initial capacity must be greater than 0");
    if ((paramFloat <= 0.0F) || (Float.isNaN(paramFloat)))
      throw new IllegalArgumentException("Load factor must be greater than 0");
    this.loadFactor = paramFloat;
    this.threshold = calculateThreshold(paramInt, paramFloat);
    paramInt = calculateNewCapacity(paramInt);
    this.data = new HashEntry[paramInt];
    init();
  }

  protected AbstractHashedMap(Map<? extends K, ? extends V> paramMap)
  {
    this(Math.max(2 * paramMap.size(), 16), 0.75F);
    putAll(paramMap);
  }

  protected void init()
  {
  }

  public V get(Object paramObject)
  {
    int i = hash(paramObject == null ? NULL : paramObject);
    for (HashEntry localHashEntry = this.data[hashIndex(i, this.data.length)]; localHashEntry != null; localHashEntry = localHashEntry.next)
      if ((localHashEntry.hashCode == i) && (isEqualKey(paramObject, localHashEntry.key)))
        return localHashEntry.getValue();
    return null;
  }

  public int size()
  {
    return this.size;
  }

  public boolean isEmpty()
  {
    return this.size == 0;
  }

  public boolean containsKey(Object paramObject)
  {
    int i = hash(paramObject == null ? NULL : paramObject);
    for (HashEntry localHashEntry = this.data[hashIndex(i, this.data.length)]; localHashEntry != null; localHashEntry = localHashEntry.next)
      if ((localHashEntry.hashCode == i) && (isEqualKey(paramObject, localHashEntry.getKey())))
        return true;
    return false;
  }

  public boolean containsValue(Object paramObject)
  {
    int i;
    int j;
    HashEntry localHashEntry;
    if (paramObject == null)
    {
      i = 0;
      j = this.data.length;
      while (i < j)
      {
        for (localHashEntry = this.data[i]; localHashEntry != null; localHashEntry = localHashEntry.next)
          if (localHashEntry.getValue() == null)
            return true;
        i++;
      }
    }
    else
    {
      i = 0;
      j = this.data.length;
      while (i < j)
      {
        for (localHashEntry = this.data[i]; localHashEntry != null; localHashEntry = localHashEntry.next)
          if (isEqualValue(paramObject, localHashEntry.getValue()))
            return true;
        i++;
      }
    }
    return false;
  }

  public V put(K paramK, V paramV)
  {
    int i = hash(paramK == null ? NULL : paramK);
    int j = hashIndex(i, this.data.length);
    for (HashEntry localHashEntry = this.data[j]; localHashEntry != null; localHashEntry = localHashEntry.next)
      if ((localHashEntry.hashCode == i) && (isEqualKey(paramK, localHashEntry.getKey())))
      {
        Object localObject = localHashEntry.getValue();
        updateEntry(localHashEntry, paramV);
        return localObject;
      }
    addMapping(j, i, paramK, paramV);
    return null;
  }

  public void putAll(Map<? extends K, ? extends V> paramMap)
  {
    int i = paramMap.size();
    if (i == 0)
      return;
    int j = (int)(this.size + i / this.loadFactor + 1.0F);
    ensureCapacity(calculateNewCapacity(j));
    Iterator localIterator = paramMap.entrySet().iterator();
    while (localIterator.hasNext())
    {
      Map.Entry localEntry = (Map.Entry)localIterator.next();
      put(localEntry.getKey(), localEntry.getValue());
    }
  }

  public V remove(Object paramObject)
  {
    int i = hash(paramObject == null ? NULL : paramObject);
    int j = hashIndex(i, this.data.length);
    HashEntry localHashEntry1 = this.data[j];
    HashEntry localHashEntry2 = null;
    while (localHashEntry1 != null)
    {
      if ((localHashEntry1.hashCode == i) && (isEqualKey(paramObject, localHashEntry1.getKey())))
      {
        Object localObject = localHashEntry1.getValue();
        removeMapping(localHashEntry1, j, localHashEntry2);
        return localObject;
      }
      localHashEntry2 = localHashEntry1;
      localHashEntry1 = localHashEntry1.next;
    }
    return null;
  }

  public void clear()
  {
    this.modCount += 1;
    HashEntry[] arrayOfHashEntry = this.data;
    for (int i = arrayOfHashEntry.length - 1; i >= 0; i--)
      arrayOfHashEntry[i] = null;
    this.size = 0;
  }

  protected int hash(Object paramObject)
  {
    int i = paramObject.hashCode();
    i += (i << 9 ^ 0xFFFFFFFF);
    i ^= i >>> 14;
    i += (i << 4);
    i ^= i >>> 10;
    return i;
  }

  protected boolean isEqualKey(Object paramObject1, Object paramObject2)
  {
    return (paramObject1 == paramObject2) || ((paramObject1 != null) && (paramObject1.equals(paramObject2)));
  }

  protected boolean isEqualValue(Object paramObject1, Object paramObject2)
  {
    return (paramObject1 == paramObject2) || (paramObject1.equals(paramObject2));
  }

  protected int hashIndex(int paramInt1, int paramInt2)
  {
    return paramInt1 & paramInt2 - 1;
  }

  protected HashEntry<K, V> getEntry(Object paramObject)
  {
    int i = hash(paramObject == null ? NULL : paramObject);
    for (HashEntry localHashEntry = this.data[hashIndex(i, this.data.length)]; localHashEntry != null; localHashEntry = localHashEntry.next)
      if ((localHashEntry.hashCode == i) && (isEqualKey(paramObject, localHashEntry.getKey())))
        return localHashEntry;
    return null;
  }

  protected void updateEntry(HashEntry<K, V> paramHashEntry, V paramV)
  {
    paramHashEntry.setValue(paramV);
  }

  protected void reuseEntry(HashEntry<K, V> paramHashEntry, int paramInt1, int paramInt2, K paramK, V paramV)
  {
    paramHashEntry.next = this.data[paramInt1];
    paramHashEntry.hashCode = paramInt2;
    paramHashEntry.key = paramK;
    paramHashEntry.value = paramV;
  }

  protected void addMapping(int paramInt1, int paramInt2, K paramK, V paramV)
  {
    this.modCount += 1;
    HashEntry localHashEntry = createEntry(this.data[paramInt1], paramInt2, paramK, paramV);
    addEntry(localHashEntry, paramInt1);
    this.size += 1;
    checkCapacity();
  }

  protected HashEntry<K, V> createEntry(HashEntry<K, V> paramHashEntry, int paramInt, K paramK, V paramV)
  {
    return new HashEntry(paramHashEntry, paramInt, paramK, paramV);
  }

  protected void addEntry(HashEntry<K, V> paramHashEntry, int paramInt)
  {
    this.data[paramInt] = paramHashEntry;
  }

  protected void removeMapping(HashEntry<K, V> paramHashEntry1, int paramInt, HashEntry<K, V> paramHashEntry2)
  {
    this.modCount += 1;
    removeEntry(paramHashEntry1, paramInt, paramHashEntry2);
    this.size -= 1;
    destroyEntry(paramHashEntry1);
  }

  protected void removeEntry(HashEntry<K, V> paramHashEntry1, int paramInt, HashEntry<K, V> paramHashEntry2)
  {
    if (paramHashEntry2 == null)
      this.data[paramInt] = paramHashEntry1.next;
    else
      paramHashEntry2.next = paramHashEntry1.next;
  }

  protected void destroyEntry(HashEntry<K, V> paramHashEntry)
  {
    paramHashEntry.next = null;
    paramHashEntry.key = null;
    paramHashEntry.value = null;
  }

  protected void checkCapacity()
  {
    if (this.size >= this.threshold)
    {
      int i = this.data.length * 2;
      if (i <= 1073741824)
        ensureCapacity(i);
    }
  }

  protected void ensureCapacity(int paramInt)
  {
    int i = this.data.length;
    if (paramInt <= i)
      return;
    if (this.size == 0)
    {
      this.threshold = calculateThreshold(paramInt, this.loadFactor);
      this.data = new HashEntry[paramInt];
    }
    else
    {
      HashEntry[] arrayOfHashEntry1 = this.data;
      HashEntry[] arrayOfHashEntry2 = new HashEntry[paramInt];
      this.modCount += 1;
      for (int j = i - 1; j >= 0; j--)
      {
        Object localObject = arrayOfHashEntry1[j];
        if (localObject != null)
        {
          arrayOfHashEntry1[j] = null;
          do
          {
            HashEntry localHashEntry = ((HashEntry)localObject).next;
            int k = hashIndex(((HashEntry)localObject).hashCode, paramInt);
            ((HashEntry)localObject).next = arrayOfHashEntry2[k];
            arrayOfHashEntry2[k] = localObject;
            localObject = localHashEntry;
          }
          while (localObject != null);
        }
      }
      this.threshold = calculateThreshold(paramInt, this.loadFactor);
      this.data = arrayOfHashEntry2;
    }
  }

  protected int calculateNewCapacity(int paramInt)
  {
    int i = 1;
    if (paramInt > 1073741824)
    {
      i = 1073741824;
    }
    else
    {
      while (i < paramInt)
        i <<= 1;
      if (i > 1073741824)
        i = 1073741824;
    }
    return i;
  }

  protected int calculateThreshold(int paramInt, float paramFloat)
  {
    return (int)(paramInt * paramFloat);
  }

  protected HashEntry<K, V> entryNext(HashEntry<K, V> paramHashEntry)
  {
    return paramHashEntry.next;
  }

  protected int entryHashCode(HashEntry<K, V> paramHashEntry)
  {
    return paramHashEntry.hashCode;
  }

  protected K entryKey(HashEntry<K, V> paramHashEntry)
  {
    return paramHashEntry.key;
  }

  protected V entryValue(HashEntry<K, V> paramHashEntry)
  {
    return paramHashEntry.value;
  }

  public MapIterator<K, V> mapIterator()
  {
    if (this.size == 0)
      return EmptyMapIterator.INSTANCE;
    return new HashMapIterator(this);
  }

  public Set<Map.Entry<K, V>> entrySet()
  {
    if (this.entrySet == null)
      this.entrySet = new EntrySet(this);
    return this.entrySet;
  }

  protected Iterator<Map.Entry<K, V>> createEntrySetIterator()
  {
    if (size() == 0)
      return EmptyIterator.INSTANCE;
    return new EntrySetIterator(this);
  }

  public Set<K> keySet()
  {
    if (this.keySet == null)
      this.keySet = new KeySet(this);
    return this.keySet;
  }

  protected Iterator<K> createKeySetIterator()
  {
    if (size() == 0)
      return EmptyIterator.INSTANCE;
    return new KeySetIterator(this);
  }

  public Collection<V> values()
  {
    if (this.values == null)
      this.values = new Values(this);
    return this.values;
  }

  protected Iterator<V> createValuesIterator()
  {
    if (size() == 0)
      return EmptyIterator.INSTANCE;
    return new ValuesIterator(this);
  }

  protected void doWriteObject(ObjectOutputStream paramObjectOutputStream)
    throws IOException
  {
    paramObjectOutputStream.writeFloat(this.loadFactor);
    paramObjectOutputStream.writeInt(this.data.length);
    paramObjectOutputStream.writeInt(this.size);
    MapIterator localMapIterator = mapIterator();
    while (localMapIterator.hasNext())
    {
      paramObjectOutputStream.writeObject(localMapIterator.next());
      paramObjectOutputStream.writeObject(localMapIterator.getValue());
    }
  }

  protected void doReadObject(ObjectInputStream paramObjectInputStream)
    throws IOException, ClassNotFoundException
  {
    this.loadFactor = paramObjectInputStream.readFloat();
    int i = paramObjectInputStream.readInt();
    int j = paramObjectInputStream.readInt();
    init();
    this.data = new HashEntry[i];
    for (int k = 0; k < j; k++)
    {
      Object localObject1 = paramObjectInputStream.readObject();
      Object localObject2 = paramObjectInputStream.readObject();
      put(localObject1, localObject2);
    }
    this.threshold = calculateThreshold(this.data.length, this.loadFactor);
  }

  protected Object clone()
  {
    try
    {
      AbstractHashedMap localAbstractHashedMap = (AbstractHashedMap)super.clone();
      localAbstractHashedMap.data = new HashEntry[this.data.length];
      localAbstractHashedMap.entrySet = null;
      localAbstractHashedMap.keySet = null;
      localAbstractHashedMap.values = null;
      localAbstractHashedMap.modCount = 0;
      localAbstractHashedMap.size = 0;
      localAbstractHashedMap.init();
      localAbstractHashedMap.putAll(this);
      return localAbstractHashedMap;
    }
    catch (CloneNotSupportedException localCloneNotSupportedException)
    {
    }
    return null;
  }

  public boolean equals(Object paramObject)
  {
    if (paramObject == this)
      return true;
    if (!(paramObject instanceof Map))
      return false;
    Map localMap = (Map)paramObject;
    if (localMap.size() != size())
      return false;
    MapIterator localMapIterator = mapIterator();
    try
    {
      while (localMapIterator.hasNext())
      {
        Object localObject1 = localMapIterator.next();
        Object localObject2 = localMapIterator.getValue();
        if (localObject2 == null)
        {
          if ((localMap.get(localObject1) != null) || (!localMap.containsKey(localObject1)))
            return false;
        }
        else if (!localObject2.equals(localMap.get(localObject1)))
          return false;
      }
    }
    catch (ClassCastException localClassCastException)
    {
      return false;
    }
    catch (NullPointerException localNullPointerException)
    {
      return false;
    }
    return true;
  }

  public int hashCode()
  {
    int i = 0;
    Iterator localIterator = createEntrySetIterator();
    while (localIterator.hasNext())
      i += localIterator.next().hashCode();
    return i;
  }

  public String toString()
  {
    if (size() == 0)
      return "{}";
    StringBuilder localStringBuilder = new StringBuilder(32 * size());
    localStringBuilder.append('{');
    MapIterator localMapIterator = mapIterator();
    boolean bool = localMapIterator.hasNext();
    while (bool)
    {
      Object localObject1 = localMapIterator.next();
      Object localObject2 = localMapIterator.getValue();
      localStringBuilder.append(localObject1 == this ? "(this Map)" : localObject1).append('=').append(localObject2 == this ? "(this Map)" : localObject2);
      bool = localMapIterator.hasNext();
      if (bool)
        localStringBuilder.append(',').append(' ');
    }
    localStringBuilder.append('}');
    return localStringBuilder.toString();
  }

  protected static class EntrySet<K, V> extends AbstractSet<Map.Entry<K, V>>
  {
    protected final AbstractHashedMap<K, V> parent;

    protected EntrySet(AbstractHashedMap<K, V> paramAbstractHashedMap)
    {
      this.parent = paramAbstractHashedMap;
    }

    public int size()
    {
      return this.parent.size();
    }

    public void clear()
    {
      this.parent.clear();
    }

    public boolean contains(Map.Entry<K, V> paramEntry)
    {
      Map.Entry<K, V> localEntry = paramEntry;
      AbstractHashedMap.HashEntry localHashEntry = this.parent.getEntry(localEntry.getKey());
      return (localHashEntry != null) && (localHashEntry.equals(localEntry));
    }

    public boolean remove(Object paramObject)
    {
      if (!(paramObject instanceof Map.Entry))
        return false;
      if (!contains(paramObject))
        return false;
      Map.Entry localEntry = (Map.Entry)paramObject;
      Object localObject = localEntry.getKey();
      this.parent.remove(localObject);
      return true;
    }

    public Iterator<Map.Entry<K, V>> iterator()
    {
      return this.parent.createEntrySetIterator();
    }
  }

  protected static class EntrySetIterator<K, V> extends AbstractHashedMap.HashIterator<K, V>
    implements Iterator<Map.Entry<K, V>>
  {
    protected EntrySetIterator(AbstractHashedMap<K, V> paramAbstractHashedMap)
    {
      super();
    }

    public AbstractHashedMap.HashEntry<K, V> next()
    {
      return super.nextEntry();
    }
  }

  protected static class HashEntry<K, V>
    implements Map.Entry<K, V>, KeyValue<K, V>
  {
    protected HashEntry<K, V> next;
    protected int hashCode;
    private K key;
    private V value;

    protected HashEntry(HashEntry<K, V> paramHashEntry, int paramInt, K paramK, V paramV)
    {
      this.next = paramHashEntry;
      this.hashCode = paramInt;
      this.key = paramK;
      this.value = paramV;
    }

    public K getKey()
    {
      return this.key;
    }

    public void setKey(K paramK)
    {
      this.key = paramK;
    }

    public V getValue()
    {
      return this.value;
    }

    public V setValue(V paramV)
    {
      Object localObject = this.value;
      this.value = paramV;
      return localObject;
    }

    public boolean equals(Object paramObject)
    {
      if (paramObject == this)
        return true;
      if (!(paramObject instanceof Map.Entry))
        return false;
      Map.Entry localEntry = (Map.Entry)paramObject;
      return (getKey() == null ? localEntry.getKey() == null : getKey().equals(localEntry.getKey())) && (getValue() == null ? localEntry.getValue() == null : getValue().equals(localEntry.getValue()));
    }

    public int hashCode()
    {
      return (getKey() == null ? 0 : getKey().hashCode()) ^ (getValue() == null ? 0 : getValue().hashCode());
    }

    public String toString()
    {
      return getKey() + '=' + getValue();
    }
  }

  protected static abstract class HashIterator<K, V>
  {
    protected final AbstractHashedMap parent;
    protected int hashIndex;
    protected AbstractHashedMap.HashEntry<K, V> last;
    protected AbstractHashedMap.HashEntry<K, V> next;
    protected int expectedModCount;

    protected HashIterator(AbstractHashedMap<K, V> paramAbstractHashedMap)
    {
      this.parent = paramAbstractHashedMap;
      AbstractHashedMap.HashEntry[] arrayOfHashEntry = paramAbstractHashedMap.data;
      int i = arrayOfHashEntry.length;
      for (AbstractHashedMap.HashEntry localHashEntry = null; (i > 0) && (localHashEntry == null); localHashEntry = arrayOfHashEntry[(--i)]);
      this.next = localHashEntry;
      this.hashIndex = i;
      this.expectedModCount = paramAbstractHashedMap.modCount;
    }

    public boolean hasNext()
    {
      return this.next != null;
    }

    protected AbstractHashedMap.HashEntry<K, V> nextEntry()
    {
      if (this.parent.modCount != this.expectedModCount)
        throw new ConcurrentModificationException();
      AbstractHashedMap.HashEntry localHashEntry1 = this.next;
      if (localHashEntry1 == null)
        throw new NoSuchElementException("No next() entry in the iteration");
      AbstractHashedMap.HashEntry[] arrayOfHashEntry = this.parent.data;
      int i = this.hashIndex;
      for (AbstractHashedMap.HashEntry localHashEntry2 = localHashEntry1.next; (localHashEntry2 == null) && (i > 0); localHashEntry2 = arrayOfHashEntry[(--i)]);
      this.next = localHashEntry2;
      this.hashIndex = i;
      this.last = localHashEntry1;
      return localHashEntry1;
    }

    protected AbstractHashedMap.HashEntry<K, V> currentEntry()
    {
      return this.last;
    }

    public void remove()
    {
      if (this.last == null)
        throw new IllegalStateException("remove() can only be called once after next()");
      if (this.parent.modCount != this.expectedModCount)
        throw new ConcurrentModificationException();
      this.parent.remove(this.last.getKey());
      this.last = null;
      this.expectedModCount = this.parent.modCount;
    }

    public String toString()
    {
      if (this.last != null)
        return "Iterator[" + this.last.getKey() + "=" + this.last.getValue() + "]";
      return "Iterator[]";
    }
  }

  protected static class HashMapIterator<K, V> extends AbstractHashedMap.HashIterator<K, V>
    implements MapIterator<K, V>
  {
    protected HashMapIterator(AbstractHashedMap<K, V> paramAbstractHashedMap)
    {
      super();
    }

    public K next()
    {
      return super.nextEntry().getKey();
    }

    public K getKey()
    {
      AbstractHashedMap.HashEntry localHashEntry = currentEntry();
      if (localHashEntry == null)
        throw new IllegalStateException("getKey() can only be called after next() and before remove()");
      return localHashEntry.getKey();
    }

    public V getValue()
    {
      AbstractHashedMap.HashEntry localHashEntry = currentEntry();
      if (localHashEntry == null)
        throw new IllegalStateException("getValue() can only be called after next() and before remove()");
      return localHashEntry.getValue();
    }

    public V setValue(V paramV)
    {
      AbstractHashedMap.HashEntry localHashEntry = currentEntry();
      if (localHashEntry == null)
        throw new IllegalStateException("setValue() can only be called after next() and before remove()");
      return localHashEntry.setValue(paramV);
    }
  }

  protected static class KeySet<K, V> extends AbstractSet<K>
  {
    protected final AbstractHashedMap<K, V> parent;

    protected KeySet(AbstractHashedMap<K, V> paramAbstractHashedMap)
    {
      this.parent = paramAbstractHashedMap;
    }

    public int size()
    {
      return this.parent.size();
    }

    public void clear()
    {
      this.parent.clear();
    }

    public boolean contains(Object paramObject)
    {
      return this.parent.containsKey(paramObject);
    }

    public boolean remove(Object paramObject)
    {
      boolean bool = this.parent.containsKey(paramObject);
      this.parent.remove(paramObject);
      return bool;
    }

    public Iterator<K> iterator()
    {
      return this.parent.createKeySetIterator();
    }
  }

  protected static class KeySetIterator<K, V> extends AbstractHashedMap.HashIterator<K, V>
    implements Iterator<K>
  {
    protected KeySetIterator(AbstractHashedMap<K, V> paramAbstractHashedMap)
    {
      super();
    }

    public K next()
    {
      return super.nextEntry().getKey();
    }
  }

  protected static class Values<K, V> extends AbstractCollection<V>
  {
    protected final AbstractHashedMap<K, V> parent;

    protected Values(AbstractHashedMap<K, V> paramAbstractHashedMap)
    {
      this.parent = paramAbstractHashedMap;
    }

    public int size()
    {
      return this.parent.size();
    }

    public void clear()
    {
      this.parent.clear();
    }

    public boolean contains(Object paramObject)
    {
      return this.parent.containsValue(paramObject);
    }

    public Iterator<V> iterator()
    {
      return this.parent.createValuesIterator();
    }
  }

  protected static class ValuesIterator<K, V> extends AbstractHashedMap.HashIterator<K, V>
    implements Iterator<V>
  {
    protected ValuesIterator(AbstractHashedMap<K, V> paramAbstractHashedMap)
    {
      super();
    }

    public V next()
    {
      return super.nextEntry().getValue();
    }
  }
}

/* Location:           D:\hygieia\userclient\common\libs\easemobchat_2.1.8.jar
 * Qualified Name:     org.jivesoftware.smack.util.collections.AbstractHashedMap
 * JD-Core Version:    0.6.1
 */